home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / Kubuntu 8.10 / kubuntu-8.10-desktop-i386.iso / casper / filesystem.squashfs / usr / lib / python2.5 / mailcap.pyc (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-29  |  7KB  |  294 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.5)
  3.  
  4. '''Mailcap file handling.  See RFC 1524.'''
  5. import os
  6. __all__ = [
  7.     'getcaps',
  8.     'findmatch']
  9.  
  10. def getcaps():
  11.     '''Return a dictionary containing the mailcap database.
  12.  
  13.     The dictionary maps a MIME type (in all lowercase, e.g. \'text/plain\')
  14.     to a list of dictionaries corresponding to mailcap entries.  The list
  15.     collects all the entries for that MIME type from all available mailcap
  16.     files.  Each dictionary contains key-value pairs for that MIME type,
  17.     where the viewing command is stored with the key "view".
  18.  
  19.     '''
  20.     caps = { }
  21.     for mailcap in listmailcapfiles():
  22.         
  23.         try:
  24.             fp = open(mailcap, 'r')
  25.         except IOError:
  26.             continue
  27.  
  28.         morecaps = readmailcapfile(fp)
  29.         fp.close()
  30.         for key, value in morecaps.iteritems():
  31.             if key not in caps:
  32.                 caps[key] = value
  33.                 continue
  34.             caps[key] = caps[key] + value
  35.         
  36.     
  37.     return caps
  38.  
  39.  
  40. def listmailcapfiles():
  41.     '''Return a list of all mailcap files found on the system.'''
  42.     if 'MAILCAPS' in os.environ:
  43.         str = os.environ['MAILCAPS']
  44.         mailcaps = str.split(':')
  45.     elif 'HOME' in os.environ:
  46.         home = os.environ['HOME']
  47.     else:
  48.         home = '.'
  49.     mailcaps = [
  50.         home + '/.mailcap',
  51.         '/etc/mailcap',
  52.         '/usr/etc/mailcap',
  53.         '/usr/local/etc/mailcap']
  54.     return mailcaps
  55.  
  56.  
  57. def readmailcapfile(fp):
  58.     '''Read a mailcap file and return a dictionary keyed by MIME type.
  59.  
  60.     Each MIME type is mapped to an entry consisting of a list of
  61.     dictionaries; the list will contain more than one such dictionary
  62.     if a given MIME type appears more than once in the mailcap file.
  63.     Each dictionary contains key-value pairs for that MIME type, where
  64.     the viewing command is stored with the key "view".
  65.     '''
  66.     caps = { }
  67.     while None:
  68.         line = fp.readline()
  69.         if not line:
  70.             break
  71.         
  72.         if line[0] == '#' or line.strip() == '':
  73.             continue
  74.         
  75.         nextline = line
  76.         while nextline[-2:] == '\\\n':
  77.             nextline = fp.readline()
  78.             if not nextline:
  79.                 nextline = '\n'
  80.             
  81.             line = line[:-2] + nextline
  82.         (key, fields) = parseline(line)
  83.         if not key and fields:
  84.             continue
  85.         
  86.         types = key.split('/')
  87.         for j in range(len(types)):
  88.             types[j] = types[j].strip()
  89.         
  90.         key = '/'.join(types).lower()
  91.         if key in caps:
  92.             caps[key].append(fields)
  93.             continue
  94.         caps[key] = [
  95.             fields]
  96.         continue
  97.         return caps
  98.  
  99.  
  100. def parseline(line):
  101.     '''Parse one entry in a mailcap file and return a dictionary.
  102.  
  103.     The viewing command is stored as the value with the key "view",
  104.     and the rest of the fields produce key-value pairs in the dict.
  105.     '''
  106.     fields = []
  107.     i = 0
  108.     n = len(line)
  109.     while i < n:
  110.         (field, i) = parsefield(line, i, n)
  111.         fields.append(field)
  112.         i = i + 1
  113.     if len(fields) < 2:
  114.         return (None, None)
  115.     
  116.     key = fields[0]
  117.     view = fields[1]
  118.     rest = fields[2:]
  119.     fields = {
  120.         'view': view }
  121.     for field in rest:
  122.         i = field.find('=')
  123.         if i < 0:
  124.             fkey = field
  125.             fvalue = ''
  126.         else:
  127.             fkey = field[:i].strip()
  128.             fvalue = field[i + 1:].strip()
  129.         if fkey in fields:
  130.             continue
  131.         fields[fkey] = fvalue
  132.     
  133.     return (key, fields)
  134.  
  135.  
  136. def parsefield(line, i, n):
  137.     '''Separate one key-value pair in a mailcap entry.'''
  138.     start = i
  139.     while i < n:
  140.         c = line[i]
  141.         if c == ';':
  142.             break
  143.             continue
  144.         if c == '\\':
  145.             i = i + 2
  146.             continue
  147.         i = i + 1
  148.     return (line[start:i].strip(), i)
  149.  
  150.  
  151. def findmatch(caps, MIMEtype, key = 'view', filename = '/dev/null', plist = []):
  152.     """Find a match for a mailcap entry.
  153.  
  154.     Return a tuple containing the command line, and the mailcap entry
  155.     used; (None, None) if no match is found.  This may invoke the
  156.     'test' command of several matching entries before deciding which
  157.     entry to use.
  158.  
  159.     """
  160.     entries = lookup(caps, MIMEtype, key)
  161.     for e in entries:
  162.         if 'test' in e:
  163.             test = subst(e['test'], filename, plist)
  164.             if test and os.system(test) != 0:
  165.                 continue
  166.             
  167.         
  168.         command = subst(e[key], MIMEtype, filename, plist)
  169.         return (command, e)
  170.     
  171.     return (None, None)
  172.  
  173.  
  174. def lookup(caps, MIMEtype, key = None):
  175.     entries = []
  176.     if MIMEtype in caps:
  177.         entries = entries + caps[MIMEtype]
  178.     
  179.     MIMEtypes = MIMEtype.split('/')
  180.     MIMEtype = MIMEtypes[0] + '/*'
  181.     if MIMEtype in caps:
  182.         entries = entries + caps[MIMEtype]
  183.     
  184.     if key is not None:
  185.         entries = filter((lambda e, key = key: key in e), entries)
  186.     
  187.     return entries
  188.  
  189.  
  190. def subst(field, MIMEtype, filename, plist = []):
  191.     res = ''
  192.     i = 0
  193.     n = len(field)
  194.     while i < n:
  195.         c = field[i]
  196.         i = i + 1
  197.         if c != '%':
  198.             if c == '\\':
  199.                 c = field[i:i + 1]
  200.                 i = i + 1
  201.             
  202.             res = res + c
  203.             continue
  204.         c = field[i]
  205.         i = i + 1
  206.         if c == '%':
  207.             res = res + c
  208.             continue
  209.         if c == 's':
  210.             res = res + filename
  211.             continue
  212.         if c == 't':
  213.             res = res + MIMEtype
  214.             continue
  215.         if c == '{':
  216.             start = i
  217.             while i < n and field[i] != '}':
  218.                 i = i + 1
  219.             name = field[start:i]
  220.             i = i + 1
  221.             res = res + findparam(name, plist)
  222.             continue
  223.         res = res + '%' + c
  224.     return res
  225.  
  226.  
  227. def findparam(name, plist):
  228.     name = name.lower() + '='
  229.     n = len(name)
  230.     for p in plist:
  231.         if p[:n].lower() == name:
  232.             return p[n:]
  233.             continue
  234.     
  235.     return ''
  236.  
  237.  
  238. def test():
  239.     import sys as sys
  240.     caps = getcaps()
  241.     if not sys.argv[1:]:
  242.         show(caps)
  243.         return None
  244.     
  245.     for i in range(1, len(sys.argv), 2):
  246.         args = sys.argv[i:i + 2]
  247.         if len(args) < 2:
  248.             print 'usage: mailcap [MIMEtype file] ...'
  249.             return None
  250.         
  251.         MIMEtype = args[0]
  252.         file = args[1]
  253.         (command, e) = findmatch(caps, MIMEtype, 'view', file)
  254.         if not command:
  255.             print 'No viewer found for', type
  256.             continue
  257.         print 'Executing:', command
  258.         sts = os.system(command)
  259.         if sts:
  260.             print 'Exit status:', sts
  261.             continue
  262.     
  263.  
  264.  
  265. def show(caps):
  266.     print 'Mailcap files:'
  267.     for fn in listmailcapfiles():
  268.         print '\t' + fn
  269.     
  270.     print 
  271.     if not caps:
  272.         caps = getcaps()
  273.     
  274.     print 'Mailcap entries:'
  275.     print 
  276.     ckeys = caps.keys()
  277.     ckeys.sort()
  278.     for type in ckeys:
  279.         print type
  280.         entries = caps[type]
  281.         for e in entries:
  282.             keys = e.keys()
  283.             keys.sort()
  284.             for k in keys:
  285.                 print '  %-15s' % k, e[k]
  286.             
  287.             print 
  288.         
  289.     
  290.  
  291. if __name__ == '__main__':
  292.     test()
  293.  
  294.